home *** CD-ROM | disk | FTP | other *** search
/ ADA Programming Guide / ADA Programming Guide.iso / ada_gwu / cwkform.c < prev    next >
C/C++ Source or Header  |  1996-01-30  |  6KB  |  325 lines
  1.  
  2.  
  3. /*
  4.     GWMON Parallel Ada Monitor for 386/486 PCs   
  5.     Copyright (C) 1993, Charles W. Kann  & Michael Bliss Feldman
  6.                         ckann@seas.gwu.edu mfeldman@seas.gwu.edu
  7.  
  8.     This program is free software; you can redistribute it and/or modify
  9.     it under the terms of the GNU General Public License as published by
  10.     the Free Software Foundation; either version 2 of the License.
  11.  
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  16.  
  17.     You should have received a copy of the GNU General Public License
  18.     along with this program; if not, write to the Free Software
  19.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21. */
  22.  
  23. #include "ed.h"
  24. #include "keydef.h"
  25. #define DISPLAY_ONLY -1
  26.  
  27. int
  28. CWK_Get_Int( mode, save_row, save_col, length, initial_value, print_help )
  29. int mode, save_row, save_col, length, *initial_value;
  30. void (*print_help) ();
  31. {
  32.     int ret_val, col, icnt;
  33.     int process;
  34.     char digit;
  35.     char *save_string, format[20];
  36.  
  37.     ret_val = 0;
  38.     col = save_col;
  39.  
  40.     save_string = (char *) malloc( ( sizeof(char) * length ) + 1 );
  41.     sprintf( format, "%c-%2.2d.1d", '%', length );
  42.     sprintf( save_string, format, *initial_value );
  43.  
  44.     process = 1;
  45.     while( process )
  46.     {
  47.         _settextposition( save_row, save_col );
  48.         _outtext( save_string );
  49.         if ( mode == DISPLAY_ONLY )
  50.             return -2;
  51.         _settextposition( save_row, col );
  52.         digit = getch();
  53.         switch ( digit ) {
  54.  
  55.         case ESC :
  56.             ret_val = -1;
  57.             process = 0;
  58.             break;
  59.             
  60.         case CTRL_M :
  61.         case CTRL_I :
  62.             process = 0;
  63.             break;
  64.  
  65.         case '?' :
  66.             print_help();
  67.             break;
  68.  
  69.         case CTRL_H :
  70.             if ( --col < save_col )
  71.             {
  72.                 col = save_col;
  73.             }
  74.             else
  75.             {
  76.                 for ( icnt = col - save_col; icnt < length-1;
  77.                       ++icnt )
  78.                 {
  79.                     save_string[icnt] = save_string[icnt+1];
  80.                 }
  81.                 save_string[length-1] = ' ';
  82.             }
  83.             break;
  84.  
  85.         case DEL :
  86.             for ( icnt = col - save_col; icnt < length-1;
  87.                   ++icnt )
  88.             {
  89.                 save_string[icnt] = save_string[icnt+1];
  90.             }
  91.             save_string[length-1] = ' ';
  92.             break;
  93.  
  94.         case LEFTARROW :
  95.             if ( --col < save_col )
  96.             {
  97.                 col = save_col;
  98.             }
  99.             break;
  100.  
  101.         case RIGHTARROW :
  102.             if ( ++col > save_col + length - 1 )
  103.             {
  104.                 col = save_col + length - 1;
  105.             }
  106.             break;
  107.  
  108.         case  '0' :
  109.         case  '1' :
  110.         case  '2' :
  111.         case  '3' :
  112.         case  '4' :
  113.         case  '5' :
  114.         case  '6' :
  115.         case  '7' :
  116.         case  '8' :
  117.         case  '9' :
  118.         case  ' ' :
  119.             save_string[col-save_col] = digit;
  120.             if ( ++col > save_col + length - 1 )
  121.             {
  122.                 col = save_col + length - 1;
  123.             }
  124.             break;
  125.         default :
  126.             break;
  127.         }
  128.     }
  129.  
  130.     *initial_value = 0;
  131.  
  132.     for ( icnt = 0; icnt < length; ++icnt )
  133.     {
  134.         if ( save_string[icnt] == ' ' )
  135.             break;
  136.         *initial_value = ( *initial_value * 10 ) + ( save_string[icnt] - '0' );
  137.     }
  138.     return ret_val;
  139. }
  140.  
  141. char *
  142. CWK_Get_String( row, col, length )
  143. int row, col, length;
  144. {
  145. }
  146.  
  147. int
  148. CWK_Get_Choice( mode, row, col, length, initial_value, choices, print_help )
  149. int mode, row, col, length, *initial_value;
  150. char **choices;
  151. void (*print_help) ();
  152. {
  153.     int process, icnt, Number_Of_Choices, choice, ret_val;
  154.     char *msg, format[40];
  155.  
  156.     ret_val = 0;
  157.  
  158.     msg = (char *) malloc( (sizeof(msg)*length) + 1 );
  159.  
  160.     Number_Of_Choices = 0;
  161.     while( 1 )
  162.     {
  163.         if ( *choices[Number_Of_Choices] == '\0' )
  164.             break;
  165.         Number_Of_Choices++;
  166.     }
  167.     Number_Of_Choices--;
  168.  
  169.     icnt = *initial_value;
  170.     process = 1;
  171.     while( process )
  172.     {
  173.         if ( icnt < 0 )
  174.             icnt = Number_Of_Choices;
  175.         else if ( *choices[icnt] == '\0' )
  176.         {
  177.             icnt = 0;
  178.         }
  179.  
  180.         sprintf( format, "%c-%2.2d.%2.2ds", '%', length, length );
  181.         sprintf( msg, format, choices[icnt] );
  182.         _settextposition( row, col );
  183.         _outtext( msg );
  184.         if ( mode == DISPLAY_ONLY )
  185.             return -2;
  186.         _settextposition( row, col );
  187.         choice = getch();
  188.         switch (choice) {
  189.         
  190.         case ESC :
  191.             ret_val = -1;
  192.             process = 0;
  193.             break;
  194.         case CTRL_M :
  195.         case CTRL_I :
  196.             process = 0;
  197.             break;
  198.         case '?' :
  199.             print_help();
  200.             break;
  201.  
  202.         case UPARROW :
  203.             icnt--;
  204.             break;
  205.         case DOWNARROW :
  206.             icnt++;
  207.             break;
  208.         default :
  209.             break;
  210.         }
  211.     }
  212.     *initial_value = icnt;
  213.     return ret_val;
  214. }
  215.  
  216. long
  217. CWK_Get_Long( mode, save_row, save_col, length, initial_value )
  218. int mode, save_row, save_col, length;
  219. long *initial_value;
  220. {
  221.     int  col, icnt;
  222.     long ret_val;
  223.     int process;
  224.     char digit;
  225.     char *save_string, format[20];
  226.  
  227.     ret_val = 0;
  228.     col = save_col;
  229.  
  230.     save_string = (char *) malloc( ( sizeof(char) * length ) + 1 );
  231.     sprintf( format, "%c-%2.2d.1d", '%', length );
  232.     sprintf( save_string, format, *initial_value );
  233.  
  234.     process = 1;
  235.     while( process )
  236.     {
  237.         _settextposition( save_row, save_col );
  238.         _outtext( save_string );
  239.         if ( mode == DISPLAY_ONLY )
  240.             return -2;
  241.         _settextposition( save_row, col );
  242.         digit = getch();
  243.         switch ( digit ) {
  244.  
  245.         case ESC :
  246.             ret_val = -1;
  247.             process = 0;
  248.             break;
  249.         case CTRL_M :
  250.         case CTRL_I :
  251.             process = 0;
  252.             break;
  253.  
  254.         case CTRL_H :
  255.             if ( --col < save_col )
  256.             {
  257.                 col = save_col;
  258.             }
  259.             else
  260.             {
  261.                 for ( icnt = col - save_col; icnt < length-1;
  262.                       ++icnt )
  263.                 {
  264.                     save_string[icnt] = save_string[icnt+1];
  265.                 }
  266.                 save_string[length-1] = ' ';
  267.             }
  268.             break;
  269.  
  270.         case DEL :
  271.             for ( icnt = col - save_col; icnt < length-1;
  272.                   ++icnt )
  273.             {
  274.                 save_string[icnt] = save_string[icnt+1];
  275.             }
  276.             save_string[length-1] = ' ';
  277.             break;
  278.  
  279.         case LEFTARROW :
  280.             if ( --col < save_col )
  281.             {
  282.                 col = save_col;
  283.             }
  284.             break;
  285.  
  286.         case RIGHTARROW :
  287.             if ( ++col > save_col + length - 1 )
  288.             {
  289.                 col = save_col + length - 1;
  290.             }
  291.             break;
  292.  
  293.         case  '0' :
  294.         case  '1' :
  295.         case  '2' :
  296.         case  '3' :
  297.         case  '4' :
  298.         case  '5' :
  299.         case  '6' :
  300.         case  '7' :
  301.         case  '8' :
  302.         case  '9' :
  303.         case  ' ' :
  304.             save_string[col-save_col] = digit;
  305.             if ( ++col > save_col + length - 1 )
  306.             {
  307.                 col = save_col + length - 1;
  308.             }
  309.             break;
  310.         default :
  311.             break;
  312.         }
  313.     }
  314.  
  315.     *initial_value = 0;
  316.  
  317.     for ( icnt = 0; icnt < length; ++icnt )
  318.     {
  319.         if ( save_string[icnt] == ' ' )
  320.             break;
  321.         *initial_value = ( *initial_value * 10 ) + ( save_string[icnt] - '0' );
  322.     }
  323.     return ret_val;
  324. }
  325.